home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Mac / Modules / snd / sndsupport.py < prev   
Text File  |  1995-06-09  |  6KB  |  227 lines
  1. # This script generates the Sound interface for Python.
  2. # It uses the "bgen" package to generate C code.
  3. # It execs the file sndgen.py which contain the function definitions
  4. # (sndgen.py was generated by sndscan.py, scanning the <Sound.h> header file).
  5.  
  6. import addpack
  7. addpack.addpack(':Tools:bgen:bgen')
  8.  
  9. from macsupport import *
  10.  
  11.  
  12. # define our own function and module generators
  13.  
  14. class SndMixIn: pass
  15.  
  16. class SndFunction(SndMixIn, OSErrFunctionGenerator): pass
  17. class SndMethod(SndMixIn, OSErrMethodGenerator): pass
  18.  
  19.  
  20. # includestuff etc. are imported from macsupport
  21.  
  22. includestuff = includestuff + """
  23. #include <Sound.h>
  24.  
  25. #ifndef HAVE_UNIVERSAL_HEADERS
  26. #define SndCallBackUPP ProcPtr
  27. #define NewSndCallBackProc(x) ((SndCallBackProcPtr)(x))
  28. #define SndListHandle Handle
  29. #endif
  30. """
  31.  
  32. initstuff = initstuff + """
  33. """
  34.  
  35.  
  36. # define types used for arguments (in addition to standard and macsupport types)
  37.  
  38. class SndChannelPtrType(OpaqueByValueType):
  39.     def declare(self, name):
  40.         # Initializing all SndChannelPtr objects to 0 saves
  41.         # special-casing NewSndChannel(), where it is formally an
  42.         # input-output parameter but we treat it as output-only
  43.         # (since Python users are not supposed to allocate memory)
  44.         Output("SndChannelPtr %s = 0;", name)
  45.  
  46. SndChannelPtr = SndChannelPtrType('SndChannelPtr', 'SndCh')
  47.  
  48. SndCommand = OpaqueType('SndCommand', 'SndCmd')
  49. SndCommand_ptr = OpaqueType('SndCommand', 'SndCmd')
  50. SndListHandle = OpaqueByValueType("SndListHandle", "ResObj")
  51.  
  52. class SndCallBackType(InputOnlyType):
  53.     def __init__(self):
  54.         Type.__init__(self, 'PyObject*', 'O')
  55.     def getargsCheck(self, name):
  56.         Output("if (%s != Py_None && !PyCallable_Check(%s))", name, name)
  57.         OutLbrace()
  58.         Output('PyErr_SetString(PyExc_TypeError, "callback must be callable");')
  59.         Output("goto %s__error__;", name)
  60.         OutRbrace()
  61.     def passInput(self, name):
  62.         return "NewSndCallBackProc(SndCh_UserRoutine)"
  63.     def cleanup(self, name):
  64.         # XXX This knows it is executing inside the SndNewChannel wrapper
  65.         Output("if (_res != NULL && %s != Py_None)", name)
  66.         OutLbrace()
  67.         Output("SndChannelObject *p = (SndChannelObject *)_res;")
  68.         Output("p->ob_itself->userInfo = (long)p;")
  69.         Output("Py_INCREF(%s);", name)
  70.         Output("p->ob_callback = %s;", name)
  71.         OutRbrace()
  72.         DedentLevel()
  73.         Output(" %s__error__: ;", name)
  74.         IndentLevel()
  75.  
  76. SndCallBackProcPtr = SndCallBackType()
  77. SndCallBackUPP = SndCallBackProcPtr
  78.  
  79. SndCompletionProcPtr = FakeType('(SndCompletionProcPtr)0') # XXX
  80. SndCompletionUPP = SndCompletionProcPtr
  81.  
  82. NumVersion = OpaqueByValueType('NumVersion', 'NumVer')
  83.  
  84. ##InOutBuf128 = FixedInputOutputBufferType(128)
  85. StateBlock = StructInputOutputBufferType('StateBlock')
  86.  
  87. AudioSelectionPtr = FakeType('0') # XXX
  88.  
  89. ProcPtr = FakeType('0') # XXX
  90. FilePlayCompletionUPP = FakeType('0') # XXX
  91.  
  92. SCStatus = StructOutputBufferType('SCStatus')
  93. SMStatus = StructOutputBufferType('SMStatus')
  94. CompressionInfo = StructOutputBufferType('CompressionInfo')
  95.  
  96. includestuff = includestuff + """
  97. #include <OSUtils.h> /* for Set(Current)A5 */
  98.  
  99. /* Create a SndCommand object (an (int, int, int) tuple) */
  100. static PyObject *
  101. SndCmd_New(SndCommand *pc)
  102. {
  103.     return Py_BuildValue("hhl", pc->cmd, pc->param1, pc->param2);
  104. }
  105.  
  106. /* Convert a SndCommand argument */
  107. static int
  108. SndCmd_Convert(PyObject *v, SndCommand *pc)
  109. {
  110.     int len;
  111.     pc->param1 = 0;
  112.     pc->param2 = 0;
  113.     if (PyTuple_Check(v)) {
  114.         if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))
  115.             return 1;
  116.         PyErr_Clear();
  117.         return PyArg_ParseTuple(v, "hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);
  118.     }
  119.     return PyArg_Parse(v, "h", &pc->cmd);
  120. }
  121.  
  122. /* Create a NumVersion object (a quintuple of integers) */
  123. static PyObject *
  124. NumVer_New(NumVersion nv)
  125. {
  126.     return Py_BuildValue("iiiii",
  127.                          nv.majorRev,
  128. #ifdef THINK_C
  129.                          nv.minorRev,
  130.                          nv.bugFixRev,
  131. #else
  132.                          (nv.minorAndBugRev>>4) & 0xf,
  133.                          nv.minorAndBugRev & 0xf,
  134. #endif
  135.                          nv.stage,
  136.                          nv.nonRelRev);
  137. }
  138.  
  139. static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */
  140. """
  141.  
  142.  
  143. finalstuff = finalstuff + """
  144. /* Routine passed to Py_AddPendingCall -- call the Python callback */
  145. static int
  146. SndCh_CallCallBack(arg)
  147.     void *arg;
  148. {
  149.     SndChannelObject *p = (SndChannelObject *)arg;
  150.     PyObject *args;
  151.     PyObject *res;
  152.     args = Py_BuildValue("(O(hhl))",
  153.                          p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);
  154.     res = PyEval_CallObject(p->ob_callback, args);
  155.     Py_DECREF(args);
  156.     if (res == NULL)
  157.         return -1;
  158.     Py_DECREF(res);
  159.     return 0;
  160. }
  161.  
  162. /* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */
  163. static pascal void
  164. SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd)
  165. {
  166.     SndChannelObject *p = (SndChannelObject *)(chan->userInfo);
  167.     if (p->ob_callback != NULL) {
  168.         long A5 = SetA5(p->ob_A5);
  169.         p->ob_cmd = *cmd;
  170.         Py_AddPendingCall(SndCh_CallCallBack, (void *)p);
  171.         SetA5(A5);
  172.     }
  173. }
  174. """
  175.  
  176.  
  177. # create the module and object definition and link them
  178.  
  179. class SndObjectDefinition(ObjectDefinition):
  180.  
  181.     def outputStructMembers(self):
  182.         ObjectDefinition.outputStructMembers(self)
  183.         Output("/* Members used to implement callbacks: */")
  184.         Output("PyObject *ob_callback;")
  185.         Output("long ob_A5;");
  186.         Output("SndCommand ob_cmd;")
  187.  
  188.     def outputInitStructMembers(self):
  189.         ObjectDefinition.outputInitStructMembers(self)
  190.         Output("it->ob_callback = NULL;")
  191.         Output("it->ob_A5 = SetCurrentA5();");
  192.  
  193.     def outputCleanupStructMembers(self):
  194.         ObjectDefinition.outputCleanupStructMembers(self)
  195.         Output("Py_XDECREF(self->ob_callback);")
  196.     
  197.     def outputFreeIt(self, itselfname):
  198.         Output("SndDisposeChannel(%s, 1);", itselfname)
  199.  
  200.  
  201. sndobject = SndObjectDefinition('SndChannel', 'SndCh', 'SndChannelPtr')
  202. module = MacModule('Snd', 'Snd', includestuff, finalstuff, initstuff)
  203. module.addobject(sndobject)
  204.  
  205.  
  206. # create lists of functions and object methods
  207.  
  208. functions = []
  209. sndmethods = []
  210.  
  211.  
  212. # populate the lists
  213.  
  214. execfile('sndgen.py')
  215.  
  216.  
  217. # add the functions and methods to the module and object, respectively
  218.  
  219. for f in functions: module.add(f)
  220. for f in sndmethods: sndobject.add(f)
  221.  
  222.  
  223. # generate output
  224.  
  225. SetOutputFileName('Sndmodule.c')
  226. module.generate()
  227.